home *** CD-ROM | disk | FTP | other *** search
/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / networking / ip / ka9q / src890906.arc / SESSION.C < prev    next >
C/C++ Source or Header  |  1989-09-07  |  8KB  |  413 lines
  1. /* Session control */
  2. #include <stdio.h>
  3. #include "global.h"
  4. #include "config.h"
  5. #include "mbuf.h"
  6. #include "socket.h"
  7. #include "ftpcli.h"
  8. #include "telnet.h"
  9. #include "icmp.h"
  10. #include "ax25tnc.h"
  11. #include "session.h"
  12. #include "cmdparse.h"
  13. #include "timer.h"
  14. #include "proc.h"
  15. #include "tty.h"
  16. #include "commands.h"
  17.  
  18. struct session *Sessions;
  19. struct session *Current;
  20. int Mode = CMD_MODE;
  21.  
  22. char Notval[] = "Not a valid control block\n";
  23. static char Badsess[] = "Invalid session\n";
  24. char *Sestypes[] = {
  25.     "",
  26.     "Telnet",
  27.     "FTP",
  28.     "AX25",
  29.     "Finger",
  30.     "Ping",
  31.     "NET/ROM"
  32. };
  33.  
  34. /* Convert a character string containing a decimal session index number 
  35.  * into a pointer. If the arg is NULLCHAR, use the current default session.
  36.  * If the index is out of range or unused, return NULLSESSION.
  37.  */
  38. struct session *
  39. sessptr(cp)
  40. char *cp;
  41. {
  42.     register struct session *sp;
  43.     unsigned int i;
  44.  
  45.     if(cp == NULLCHAR){
  46.         sp = Current;
  47.     } else {
  48.         i = (unsigned)atoi(cp);
  49.         if(i >= Nsessions)
  50.             sp = NULLSESSION;
  51.         else
  52.             sp = &Sessions[i];
  53.     }
  54.     if(sp == NULLSESSION || sp->type == FREE)
  55.         sp = NULLSESSION;
  56.  
  57.     return sp;
  58. }
  59.  
  60. /* Select and display sessions */
  61. int
  62. dosession(argc,argv,p)
  63. int argc;
  64. char *argv[];
  65. void *p;
  66. {
  67.     struct session *sp;
  68.     struct sockaddr fsocket;
  69.     int i,k,s;
  70.     int r,t;
  71.     char *cp;
  72.  
  73.     sp = (struct session *)p;
  74.  
  75.     if(argc > 1){
  76.         if((sp = sessptr(argv[1])) != NULLSESSION){
  77.             go(0,NULL,sp);
  78.         } else
  79.             printf("Session %s not active\n",argv[1]);
  80.         return 0;
  81.     }
  82.     printf(" #  S#  Type     Rcv-Q Snd-Q State        Remote socket\n");
  83.     for(sp=Sessions; sp < &Sessions[Nsessions];sp++){
  84.         if(sp->type == FREE)
  85.             continue;
  86.  
  87.         i = SOCKSIZE;
  88.         s = sp->s;
  89.         k = getpeername(s,(char *)&fsocket,&i);
  90.         r = socklen(s,0);
  91.         t = socklen(s,1);
  92.         cp = sockstate(s);
  93. #ifndef    AMIGA
  94.         printf("%c%-3u%-4d%-8s%6d%6d %-13s",
  95.          (Current == sp)? '*':' ',
  96.          (unsigned)(sp - Sessions),
  97.          s,
  98.          Sestypes[sp->type],
  99.          r,
  100.          t,
  101.          (cp != NULLCHAR) ? cp : "");
  102. #else
  103.          /* compiler bug, how embarassing! */
  104.          (void)fputchar((Current == sp)? '*':' ');
  105.          printf("%-3u", sp - Sessions);
  106.          printf("%-4d%-8s%6d%6d %-13s%s", s, Sestypes[sp->type], r, t,
  107.           (cp != NULLCHAR) ? cp : "",
  108.           (sp->name != NULLCHAR) ? sp->name : "");
  109. #endif
  110.  
  111.         if(sp->name != NULLCHAR)
  112.             printf("%s ",sp->name);
  113.         if(k == 0)
  114.             printf("(%s)",psocket(&fsocket));
  115.  
  116.         if(sp->rfile != NULLCHAR || sp->ufile != NULLCHAR)
  117.             printf("\t");
  118.         if(sp->rfile != NULLCHAR)
  119.             printf("Record: %s ",sp->rfile);
  120.         if(sp->ufile != NULLCHAR)
  121.             printf("Upload: %s",sp->ufile);
  122.         printf("\n");
  123.         if(sp->type == FTP && (s = sp->cb.ftp->data) != -1){
  124.             /* Display data channel, if any */
  125.             i = SOCKSIZE;
  126.             k = getpeername(s,(char *)&fsocket,&i);
  127.             r = socklen(s,0);
  128.             t = socklen(s,1);
  129.             cp = sockstate(s);
  130.             printf("    %-4d%-8s%6d%6d %-13s%s",
  131.              s,
  132.              Sestypes[sp->type],
  133.              r,
  134.              t,
  135.              (cp != NULLCHAR) ? cp : "",
  136.              (sp->name != NULLCHAR) ? sp->name : "");
  137.             if(k == 0)
  138.                 printf(" (%s)",psocket(&fsocket));
  139.             printf("\n");
  140.         }
  141.     }
  142.     return 0;
  143. }
  144. /* Resume current session, and wait for it */
  145. int
  146. go(argc,argv,p)
  147. int argc;
  148. char *argv[];
  149. void *p;
  150. {
  151.     struct session *sp;
  152.  
  153.     sp = (struct session *)p;
  154.     if(sp == NULLSESSION || sp->type == FREE)
  155.         return 0;
  156.     Current = sp;
  157.     ttysetmode(sp->ttymode);
  158.     Mode = CONV_MODE;
  159.     psignal(sp,0);
  160.     switch(sp->type){
  161.     case TELNET:
  162.         pwait(sp->cb.telnet->output);
  163.         break;
  164.     case FTP:
  165.         pwait(sp->cb.ftp->output);
  166.         break;
  167.     case NRSESSION:
  168.     case AX25TNC:
  169.         pwait(sp->cb.ax25->output);
  170.         break;
  171.     case PING:
  172.         pwait(sp->cb.ping->proc);
  173.         break;
  174.     }
  175.     return 0;
  176. }
  177. int
  178. doclose(argc,argv,p)
  179. int argc;
  180. char *argv[];
  181. void *p;
  182. {
  183.     struct session *sp;
  184.  
  185.     sp = (struct session *)p;
  186.     if(argc > 1)
  187.         sp = sessptr(argv[1]);
  188.  
  189.     if(sp == NULLSESSION){
  190.         printf(Badsess);
  191.         return -1;
  192.     }
  193.     shutdown(sp->s,1);
  194.     return 0;
  195. }
  196. int
  197. doreset(argc,argv,p)
  198. int argc;
  199. char *argv[];
  200. void *p;
  201. {
  202.     struct session *sp;
  203.  
  204.     sp = (struct session *)p;
  205.     if(argc > 1)
  206.         sp = sessptr(argv[1]);
  207.  
  208.     if(sp == NULLSESSION){
  209.         printf(Badsess);
  210.         return -1;
  211.     }
  212.     /* Unwedge anyone waiting for a domain resolution, etc */
  213.     switch(sp->type){
  214.     case FTP:
  215.         alert(sp->cb.ftp->output,-1);
  216.         break;
  217.     case TELNET:
  218.         alert(sp->cb.telnet->output,-1);
  219.         break;
  220.     case FINGER:
  221.         alert(sp->cb.finger,-1);
  222.         break;
  223.     case AX25TNC:
  224.         break;
  225.     case PING:
  226.         alert(sp->cb.ping->proc,-1);
  227.         break;
  228.     case NRSESSION:
  229.         break;
  230.     }
  231.     shutdown(sp->s,2);
  232.     if(sp->type == FTP)
  233.         shutdown(sp->cb.ftp->data,2);
  234.     return 0;
  235. }
  236. int
  237. dokick(argc,argv,p)
  238. int argc;
  239. char *argv[];
  240. void *p;
  241. {
  242.     struct session *sp;
  243.  
  244.     sp = (struct session *)p;
  245.     if(argc > 1)
  246.         sp = sessptr(argv[1]);
  247.  
  248.     if(sp == NULLSESSION){
  249.         printf(Badsess);
  250.         return -1;
  251.     }
  252.     sockkick(sp->s);
  253.     if(sp->type == FTP)
  254.         sockkick(sp->cb.ftp->data);
  255.     return 0;
  256. }
  257.  
  258. struct session *
  259. newsession(name,type)
  260. char *name;
  261. int type;
  262. {
  263.     register struct session *sp;
  264.  
  265.     for(sp=Sessions;sp < &Sessions[Nsessions];sp++){
  266.         if(sp->type == FREE){
  267.             sp->type = type;
  268.             sp->s = -1;
  269.             if(name != NULLCHAR)
  270.                 sp->name = strdup(name);
  271.  
  272.             return sp;
  273.         }
  274.     }
  275.     return NULLSESSION;
  276. }
  277. void
  278. freesession(sp)
  279. struct session *sp;
  280. {
  281.     if(sp == NULLSESSION)
  282.         return;
  283.     if(sp->s != -1)
  284.         close_s(sp->s);
  285.     free_q(&sp->input);
  286.     if(sp->record != NULLFILE){
  287.         fclose(sp->record);
  288.         sp->record = NULLFILE;
  289.     }
  290.     free(sp->rfile);
  291.     sp->rfile = NULLCHAR;
  292.     if(sp->upload != NULLFILE){
  293.         fclose(sp->upload);
  294.         sp->upload = NULLFILE;
  295.     }
  296.     free(sp->ufile);
  297.     sp->ufile = NULLCHAR;
  298.     free(sp->name);
  299.     sp->name = NULLCHAR;
  300.     sp->type = FREE;
  301.     if(Current == sp){
  302.         Current = NULLSESSION;
  303.         Mode = CMD_MODE;
  304.     }
  305. }
  306. /* Control session recording */
  307. int
  308. dorecord(argc,argv,p)
  309. int argc;
  310. char *argv[];
  311. void *p;
  312. {
  313.     struct session *sp;
  314.  
  315.     sp = (struct session *)p;
  316.     if(sp == NULLSESSION){
  317.         printf("No current session\n");
  318.         return 1;
  319.     }
  320.     if(argc > 1){
  321.         if(sp->rfile != NULLCHAR){
  322.             fclose(sp->record);
  323.             free(sp->rfile);
  324.             sp->record = NULLFILE;
  325.             sp->rfile = NULLCHAR;
  326.         }
  327.         /* Open new record file, unless file name is "off", which means
  328.          * disable recording
  329.          */
  330.         if(strcmp(argv[1],"off") != 0){
  331.             if((sp->record = fopen(argv[1],APPEND_TEXT)) == NULLFILE)
  332.                 printf("Can't open %s: %s\n",argv[1],sys_errlist[errno]);
  333.             else
  334.                 sp->rfile = strdup(argv[1]);
  335.         }
  336.     }
  337.     if(sp->rfile != NULLCHAR)
  338.         printf("Recording into %s\n",sp->rfile);
  339.     else
  340.         printf("Recording off\n");
  341.     return 0;
  342. }
  343. /* Control file transmission */
  344. int
  345. doupload(argc,argv,p)
  346. int argc;
  347. char *argv[];
  348. void *p;
  349. {
  350.     struct telnet *tn;
  351.     struct ax25tnc *axp;
  352.     struct session *sp;
  353.  
  354.     sp = (struct session *)p;
  355.     if(sp == NULLSESSION){
  356.         printf("No current session\n");
  357.         return 1;
  358.     }
  359.     if(argc < 2){
  360.         if(sp->ufile != NULLCHAR)
  361.             printf("Uploading %s\n",sp->ufile);
  362.         else
  363.             printf("Uploading off\n");
  364.         return 0;
  365.     }
  366.     switch(sp->type){
  367.     case TELNET:
  368.         tn = sp->cb.telnet;
  369.         break;
  370.     case NRSESSION:
  371.     case AX25TNC:
  372.         axp = sp->cb.ax25;
  373.         break;
  374.     default:
  375.         printf("Uploading not supported\n");
  376.         return 1;
  377.     }
  378.     if(strcmp(argv[1],"stop") == 0 && sp->upload != NULLFILE){
  379.         /* Abort upload */
  380.         fclose(sp->upload);
  381.         sp->upload = NULLFILE;
  382.         free(sp->ufile);
  383.         sp->ufile = NULLCHAR;
  384.         if(tn != NULLTN){
  385.             killproc(tn->upload);
  386.             tn->upload = NULLPROC;
  387.         } else if(axp != NULLTNC){
  388.             killproc(axp->upload);
  389.             axp->upload = NULLPROC;
  390.         }
  391.         return 0;
  392.     }
  393.     /* Open upload file */
  394.     if((sp->upload = fopen(argv[1],READ_TEXT)) == NULLFILE){
  395.         printf("Can't read %s: %s\n",argv[1],sys_errlist[errno]);
  396.         return 1;
  397.     }
  398.     sp->ufile = strdup(argv[1]);
  399.     /* All set, invoke the upload process */
  400.     switch(sp->type){
  401. #ifdef    AX25
  402.     case NRSESSION:
  403.     case AX25TNC:
  404.         axp->upload = newproc("upload",1024,ax_upload,0,sp,NULL);
  405.         break;
  406. #endif
  407.     case TELNET:
  408.         tn->upload = newproc("upload",1024,tel_upload,0,sp,NULL);
  409.         break;
  410.     }
  411.     return 0;
  412. }
  413.